/*
    * Copyright (C) 2010 The Guava Authors
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.google.common.collect.testing;
  
  import java.io.Serializable;
  import java.util.Collection;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.NavigableSet;
  import java.util.SortedSet;
  import java.util.TreeSet;
  
  /**
   * A wrapper around {@code TreeSet} that aggressively checks to see if elements
   * are mutually comparable. This implementation passes the navigable set test
   * suites.
   *
   * @author Louis Wasserman
   */
  public final class SafeTreeSet<E> implements Serializable, NavigableSet<E> {
    @SuppressWarnings("unchecked")
    private static final Comparator<Object> NATURAL_ORDER = new Comparator<Object>() {
      @Override public int compare(Object o1, Object o2) {
        return ((Comparable<Object>) o1).compareTo(o2);
      }
    };
    private final NavigableSet<E> delegate;
  
    public SafeTreeSet() {
      this(new TreeSet<E>());
    }
  
    public SafeTreeSet(Collection<? extends E> collection) {
      this(new TreeSet<E>(collection));
    }
  
    public SafeTreeSet(Comparator<? super E> comparator) {
      this(new TreeSet<E>(comparator));
    }
  
    public SafeTreeSet(SortedSet<E> set) {
      this(new TreeSet<E>(set));
    }
  
    private SafeTreeSet(NavigableSet<E> delegate) {
      this.delegate = delegate;
      for (E e : this) {
        checkValid(e);
      }
    }
  
    @Override public boolean add(E element) {
      return delegate.add(checkValid(element));
    }
  
    @Override public boolean addAll(Collection<? extends E> collection) {
      for (E e : collection) {
        checkValid(e);
      }
      return delegate.addAll(collection);
    }
  
    @Override public E ceiling(E e) {
      return delegate.ceiling(checkValid(e));
    }
  
    @Override public void clear() {
      delegate.clear();
    }
  
    @SuppressWarnings("unchecked")
    @Override public Comparator<? super E> comparator() {
      Comparator<? super E> comparator = delegate.comparator();
      if (comparator == null) {
        comparator = (Comparator<? super E>) NATURAL_ORDER;
      }
      return comparator;
    }
  
    @Override public boolean contains(Object object) {
      return delegate.contains(checkValid(object));
    }
  
    @Override public boolean containsAll(Collection<?> c) {
      return delegate.containsAll(c);
   }
 
   @Override public Iterator<E> descendingIterator() {
     return delegate.descendingIterator();
   }
 
   @Override public NavigableSet<E> descendingSet() {
     return new SafeTreeSet<E>(delegate.descendingSet());
   }
 
   @Override public E first() {
     return delegate.first();
   }
 
   @Override public E floor(E e) {
     return delegate.floor(checkValid(e));
   }
 
   @Override public SortedSet<E> headSet(E toElement) {
     return headSet(toElement, false);
   }
 
   @Override public NavigableSet<E> headSet(E toElement, boolean inclusive) {
     return new SafeTreeSet<E>(
         delegate.headSet(checkValid(toElement), inclusive));
   }
 
   @Override public E higher(E e) {
     return delegate.higher(checkValid(e));
   }
 
   @Override public boolean isEmpty() {
     return delegate.isEmpty();
   }
 
   @Override public Iterator<E> iterator() {
     return delegate.iterator();
   }
 
   @Override public E last() {
     return delegate.last();
   }
 
   @Override public E lower(E e) {
     return delegate.lower(checkValid(e));
   }
 
   @Override public E pollFirst() {
     return delegate.pollFirst();
   }
 
   @Override public E pollLast() {
     return delegate.pollLast();
   }
 
   @Override public boolean remove(Object object) {
     return delegate.remove(checkValid(object));
   }
 
   @Override public boolean removeAll(Collection<?> c) {
     return delegate.removeAll(c);
   }
 
   @Override public boolean retainAll(Collection<?> c) {
     return delegate.retainAll(c);
   }
 
   @Override public int size() {
     return delegate.size();
   }
 
   @Override public NavigableSet<E> subSet(
       E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
     return new SafeTreeSet<E>(
         delegate.subSet(checkValid(fromElement), fromInclusive,
             checkValid(toElement), toInclusive));
   }
 
   @Override public SortedSet<E> subSet(E fromElement, E toElement) {
     return subSet(fromElement, true, toElement, false);
   }
 
   @Override public SortedSet<E> tailSet(E fromElement) {
     return tailSet(fromElement, true);
   }
 
   @Override public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
     return new SafeTreeSet<E>(delegate.tailSet(checkValid(fromElement), inclusive));
   }
 
   @Override public Object[] toArray() {
     return delegate.toArray();
   }
 
   @Override public <T> T[] toArray(T[] a) {
     return delegate.toArray(a);
   }
 
   private <T> T checkValid(T t) {
     // a ClassCastException is what's supposed to happen!
     @SuppressWarnings("unchecked")
     E e = (E) t;
     comparator().compare(e, e);
     return t;
   }
 
   @Override public boolean equals(Object obj) {
     return delegate.equals(obj);
   }
 
   @Override public int hashCode() {
     return delegate.hashCode();
   }
 
   @Override public String toString() {
     return delegate.toString();
   }
 
   private static final long serialVersionUID = 0L;
 }